import json
import requests
from flask import Blueprint, request, jsonify, current_app
from flask_jwt_extended import create_access_token
from flasgger import swag_from
from app.models.user import User
from app.models.user_attribute import UserAttribute
from app.utils.wechat import decrypt_phone_number
from app.utils.decorators import login_required
from app.utils.response import success_response, error_response

auth_bp = Blueprint('user_auth', __name__)

def get_db():
    from app import db
    return db

@auth_bp.route('/register', methods=['POST'])
@swag_from({
    'tags': ['用户认证'],
    'summary': '用户注册（小程序端）',
    'description': '微信小程序用户注册接口，一次性完成微信登录和手机号绑定，返回JWT token用于后续接口认证',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['code', 'encryptedData', 'iv'],
                'properties': {
                    'code': {'type': 'string', 'description': '微信登录code，从wx.login()获取'},
                    'encryptedData': {'type': 'string', 'description': '加密的手机号数据，从getPhoneNumber获取'},
                    'iv': {'type': 'string', 'description': '初始向量，从getPhoneNumber获取'},
                    'userInfo': {
                        'type': 'object',
                        'description': '用户基本信息（可选）',
                        'properties': {
                            'nickName': {'type': 'string', 'description': '用户昵称'},
                            'avatarUrl': {'type': 'string', 'description': '用户头像URL'},
                            'gender': {'type': 'integer', 'description': '用户性别：0-未知，1-男，2-女'}
                        }
                    }
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '注册成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '注册成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer', 'description': '用户ID'},
                            'token': {'type': 'string', 'description': 'JWT访问令牌，用于后续接口认证'},
                            'openid': {'type': 'string', 'description': '微信openid'},
                            'sessionKey': {'type': 'string', 'description': '微信会话密钥'},
                            'isNewUser': {'type': 'boolean', 'description': '是否为新用户'},
                            'phone': {'type': 'string', 'description': '绑定的手机号'},
                            'userInfo': {
                                'type': 'object',
                                'description': '用户详细信息',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'nickname': {'type': 'string'},
                                    'phone': {'type': 'string'},
                                    'avatar_url': {'type': 'string'},
                                    'gender': {'type': 'integer'},
                                    'created_at': {'type': 'string'}
                                }
                            },
                            'registerTime': {'type': 'string', 'description': '注册时间'}
                        }
                    }
                }
            }
        },
        400: {
            'description': '请求参数错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 400},
                    'message': {'type': 'string', 'example': '缺少必要参数：code, encryptedData, iv'}
                }
            }
        },
        401: {
            'description': '微信认证失败',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 401},
                    'message': {'type': 'string', 'example': '微信登录失败: invalid code'}
                }
            }
        }
    }
})
def user_register():
    """统一用户注册接口 - 一次性完成微信登录和手机号绑定"""
    db = get_db()
    data = request.get_json()
    
    # 验证必要参数
    required_fields = ['code', 'encryptedData', 'iv']
    if not data or not all(field in data for field in required_fields):
        return error_response('缺少必要参数：code, encryptedData, iv', 400)
    
    code = data.get('code')
    encrypted_data = data.get('encryptedData')
    iv = data.get('iv')
    user_info = data.get('userInfo', {})
    
    try:
        # 第一步：微信登录获取openid和sessionKey
        appid = current_app.config['WECHAT_APPID']
        secret = current_app.config['WECHAT_SECRET']
        
        url = f'https://api.weixin.qq.com/sns/jscode2session?appid={appid}&secret={secret}&js_code={code}&grant_type=authorization_code'
        
        response = requests.get(url)
        result = response.json()
        
        if 'errcode' in result and result['errcode'] != 0:
            return error_response(f"微信登录失败: {result.get('errmsg', '未知错误')}", 401)
        
        openid = result.get('openid')
        session_key = result.get('session_key')
        
        if not openid:
            return error_response('获取openid失败', 401)
        
        # 第二步：查找或创建用户
        user = User.query.filter_by(openid=openid).first()
        is_new_user = False
        
        if not user:
            # 创建新用户
            user = User(openid=openid)
            is_new_user = True
            
            # 设置用户基本信息
            if user_info:
                user.nickname = user_info.get('nickName')
                user.avatar_url = user_info.get('avatarUrl')
                user.gender = user_info.get('gender', 0)
            
            db.session.add(user)
            db.session.flush()  # 获取用户ID
        
        # 第三步：解密并绑定手机号
        phone_info = decrypt_phone_number(session_key, encrypted_data, iv)
        if not phone_info or 'phoneNumber' not in phone_info:
            return error_response('手机号解密失败', 400)
        
        phone_number = phone_info['phoneNumber']
        
        # 检查手机号是否已被其他用户绑定
        existing_user = User.query.filter_by(phone=phone_number).first()
        if existing_user and existing_user.id != user.id:
            return error_response('该手机号已被其他账号绑定', 400)
        
        # 更新用户手机号
        user.phone = phone_number
        
        # 如果是新用户且没有设置昵称，使用手机号作为默认昵称
        if is_new_user and not user.nickname:
            user.nickname = f"用户{phone_number[-4:]}"
        
        db.session.commit()
        
        # 生成JWT token
        access_token = create_access_token(identity=str(user.id))
        
        return success_response({
            'userId': user.id,
            'token': access_token,
            'openid': openid,
            'sessionKey': session_key,
            'isNewUser': is_new_user,
            'phone': phone_number,
            'userInfo': user.to_dict(),
            'registerTime': user.created_at.strftime('%Y-%m-%d %H:%M:%S') if user.created_at else None
        }, '注册成功' if is_new_user else '登录成功')
    
    except Exception as e:
        current_app.logger.error(f"用户注册异常: {str(e)}")
        db.session.rollback()
        return error_response('服务器错误', 500)

@auth_bp.route('/login', methods=['POST'])
@swag_from({
    'tags': ['用户认证'],
    'summary': '微信登录（小程序端）',
    'description': '微信小程序用户登录接口，适用于已注册用户的快速登录，返回JWT token用于后续接口认证',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['code'],
                'properties': {
                    'code': {'type': 'string', 'description': '微信登录code，从wx.login()获取'},
                    'userInfo': {
                        'type': 'object', 
                        'description': '用户信息（可选），用于更新用户资料',
                        'properties': {
                            'nickName': {'type': 'string'},
                            'avatarUrl': {'type': 'string'},
                            'gender': {'type': 'integer'}
                        }
                    }
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '登录成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '登录成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer', 'description': '用户ID'},
                            'token': {'type': 'string', 'description': 'JWT访问令牌，用于后续接口认证'},
                            'openid': {'type': 'string', 'description': '微信openid'},
                            'sessionKey': {'type': 'string', 'description': '微信会话密钥'},
                            'isNewUser': {'type': 'boolean', 'description': '是否需要完善信息（未绑定手机号）'},
                            'userInfo': {
                                'type': 'object',
                                'description': '用户详细信息',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'nickname': {'type': 'string'},
                                    'phone': {'type': 'string'},
                                    'avatar_url': {'type': 'string'},
                                    'gender': {'type': 'integer'},
                                    'created_at': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        },
        400: {
            'description': '请求参数错误'
        },
        401: {
            'description': '微信认证失败'
        }
    }
})
def user_login():
    """微信小程序登录接口"""
    db = get_db()
    data = request.get_json()
    if not data or 'code' not in data:
        return error_response('缺少必要参数：code', 400)
    
    code = data.get('code')
    
    # 请求微信接口获取openid
    appid = current_app.config['WECHAT_APPID']
    secret = current_app.config['WECHAT_SECRET']
    url = f'https://api.weixin.qq.com/sns/jscode2session?appid={appid}&secret={secret}&js_code={code}&grant_type=authorization_code'
    
    try:
        response = requests.get(url)
        result = response.json()
        
        if 'errcode' in result and result['errcode'] != 0:
            return error_response(f"微信登录失败: {result.get('errmsg', '未知错误')}", 401)
        
        openid = result.get('openid')
        session_key = result.get('session_key')
        
        if not openid:
            return error_response('获取openid失败', 401)
        
        # 查找或创建用户
        user = User.query.filter_by(openid=openid).first()
        if not user:
            user = User(openid=openid)
            db.session.add(user)
            db.session.commit()
        
        # 更新用户信息（如果请求中包含）
        if 'userInfo' in data:
            user_info = data.get('userInfo', {})
            user.nickname = user_info.get('nickName', user.nickname)
            user.avatar_url = user_info.get('avatarUrl', user.avatar_url)
            user.gender = user_info.get('gender', user.gender)
            db.session.commit()
        
        # 生成JWT token
        access_token = create_access_token(identity=str(user.id))
        
        return success_response({
            'userId': user.id,
            'token': access_token,
            'openid': openid,
            'sessionKey': session_key,
            'isNewUser': user.phone is None,  # 未绑定手机号视为新用户
            'userInfo': user.to_dict()
        }, '登录成功')
    
    except Exception as e:
        current_app.logger.error(f"用户登录异常: {str(e)}")
        return error_response('服务器错误', 500)

@auth_bp.route('/quick_login', methods=['POST'])
@swag_from({
    'tags': ['用户认证'],
    'summary': '快速登录（仅使用openid）',
    'description': '微信小程序快速登录接口，仅使用wx.login()的code即可登录，无需用户授权手机号，适合提升用户体验',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['code'],
                'properties': {
                    'code': {'type': 'string', 'description': '微信登录code，从wx.login()获取'},
                    'userInfo': {
                        'type': 'object', 
                        'description': '用户信息（可选），用于设置用户资料',
                        'properties': {
                            'nickName': {'type': 'string', 'description': '用户昵称'},
                            'avatarUrl': {'type': 'string', 'description': '用户头像URL'},
                            'gender': {'type': 'integer', 'description': '用户性别：0-未知，1-男，2-女'}
                        }
                    }
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '登录成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '登录成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer', 'description': '用户ID'},
                            'token': {'type': 'string', 'description': 'JWT访问令牌，用于后续接口认证'},
                            'openid': {'type': 'string', 'description': '微信openid'},
                            'sessionKey': {'type': 'string', 'description': '微信会话密钥'},
                            'isNewUser': {'type': 'boolean', 'description': '是否为新用户'},
                            'hasPhone': {'type': 'boolean', 'description': '是否已绑定手机号'},
                            'userInfo': {
                                'type': 'object',
                                'description': '用户详细信息',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'nickname': {'type': 'string'},
                                    'phone': {'type': 'string'},
                                    'avatar_url': {'type': 'string'},
                                    'gender': {'type': 'integer'},
                                    'created_at': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        },
        400: {
            'description': '请求参数错误'
        },
        401: {
            'description': '微信认证失败'
        }
    }
})
def quick_login():
    """快速登录接口 - 仅使用openid，无需手机号授权"""
    db = get_db()
    data = request.get_json()
    if not data or 'code' not in data:
        return error_response('缺少必要参数：code', 400)
    
    code = data.get('code')
    user_info = data.get('userInfo', {})
    
    try:
        # 请求微信接口获取openid
        appid = current_app.config['WECHAT_APPID']
        secret = current_app.config['WECHAT_SECRET']
        url = f'https://api.weixin.qq.com/sns/jscode2session?appid={appid}&secret={secret}&js_code={code}&grant_type=authorization_code'
        
        response = requests.get(url)
        result = response.json()
        
        if 'errcode' in result and result['errcode'] != 0:
            return error_response(f"微信登录失败: {result.get('errmsg', '未知错误')}", 401)
        
        openid = result.get('openid')
        session_key = result.get('session_key')
        
        if not openid:
            return error_response('获取openid失败', 401)
        
        # 查找或创建用户
        user = User.query.filter_by(openid=openid).first()
        is_new_user = False
        
        if not user:
            # 创建新用户
            user = User(openid=openid)
            is_new_user = True
            
            # 设置用户基本信息
            if user_info:
                user.nickname = user_info.get('nickName')
                user.avatar_url = user_info.get('avatarUrl')
                user.gender = user_info.get('gender', 0)
            
            # 如果没有昵称，设置默认昵称
            if not user.nickname:
                user.nickname = f"微信用户{openid[-6:]}"
            
            db.session.add(user)
            db.session.flush()  # 获取用户ID
            current_app.logger.info(f"创建新用户: openid={openid}, userId={user.id}")
        else:
            # 更新用户信息（如果提供）
            if user_info:
                if user_info.get('nickName'):
                    user.nickname = user_info.get('nickName')
                if user_info.get('avatarUrl'):
                    user.avatar_url = user_info.get('avatarUrl')
                if 'gender' in user_info:
                    user.gender = user_info.get('gender')
            current_app.logger.info(f"用户快速登录: openid={openid}, userId={user.id}")
        
        db.session.commit()
        
        # 生成JWT token
        access_token = create_access_token(identity=str(user.id))
        
        return success_response({
            'userId': user.id,
            'token': access_token,
            'openid': openid,
            'sessionKey': session_key,
            'isNewUser': is_new_user,
            'hasPhone': bool(user.phone),  # 是否已绑定手机号
            'userInfo': user.to_dict()
        }, '登录成功')
    
    except Exception as e:
        current_app.logger.error(f"快速登录异常: {str(e)}")
        db.session.rollback()
        return error_response('服务器错误', 500)

@auth_bp.route('/bind_phone', methods=['POST'])
@login_required
@swag_from({
    'tags': ['用户认证'],
    'summary': '绑定手机号',
    'description': '为已登录用户绑定手机号，需要在请求头中包含JWT token',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['encryptedData', 'iv', 'sessionKey'],
                'properties': {
                    'encryptedData': {'type': 'string', 'description': '加密的手机号数据，从getPhoneNumber获取'},
                    'iv': {'type': 'string', 'description': '初始向量，从getPhoneNumber获取'},
                    'sessionKey': {'type': 'string', 'description': '微信会话密钥，从登录时获取'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '绑定成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '手机号绑定成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer', 'description': '用户ID'},
                            'phone': {'type': 'string', 'description': '绑定的手机号'},
                            'userInfo': {
                                'type': 'object',
                                'description': '用户详细信息'
                            }
                        }
                    }
                }
            }
        },
        400: {
            'description': '请求参数错误或手机号解密失败'
        },
        401: {
            'description': 'token验证失败'
        },
        404: {
            'description': '用户不存在'
        }
    }
})
def bind_phone():
    """绑定手机号"""
    try:
        from flask import g
        db = get_db()
        
        user = User.query.get(g.current_user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        data = request.get_json()
        if not data or not all(field in data for field in ['encryptedData', 'iv', 'sessionKey']):
            return error_response('缺少必要参数：encryptedData, iv, sessionKey', 400)
        
        encrypted_data = data.get('encryptedData')
        iv = data.get('iv')
        session_key = data.get('sessionKey')
        
        # 解密手机号
        from app.utils.wechat import decrypt_phone_number
        phone_info = decrypt_phone_number(session_key, encrypted_data, iv)
        if not phone_info or 'phoneNumber' not in phone_info:
            return error_response('手机号解密失败', 400)
        
        phone_number = phone_info['phoneNumber']
        
        # 检查手机号是否已被其他用户绑定
        existing_user = User.query.filter_by(phone=phone_number).first()
        if existing_user and existing_user.id != user.id:
            return error_response('该手机号已被其他账号绑定', 400)
        
        # 更新用户手机号
        user.phone = phone_number
        db.session.commit()
        
        current_app.logger.info(f"用户绑定手机号成功: userId={user.id}, phone={phone_number}")
        
        return success_response({
            'userId': user.id,
            'phone': phone_number,
            'userInfo': user.to_dict()
        }, '手机号绑定成功')
    
    except Exception as e:
        current_app.logger.error(f"手机号绑定异常: {str(e)}")
        db.session.rollback()
        return error_response('绑定失败', 500)

@auth_bp.route('/info', methods=['GET'])
@login_required
@swag_from({
    'tags': ['用户认证'],
    'summary': '获取用户信息',
    'description': '获取当前登录用户的详细信息，包括组织的活动、参加的活动和好友列表，需要在请求头中包含JWT token',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userInfo': {
                                'type': 'object',
                                'description': '用户基本信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '用户ID'},
                                    'nickname': {'type': 'string', 'description': '用户昵称'},
                                    'phone': {'type': 'string', 'description': '手机号'},
                                    'avatar_url': {'type': 'string', 'description': '头像URL'},
                                    'gender': {'type': 'integer', 'description': '性别：0-未知，1-男，2-女'},
                                    'created_at': {'type': 'string', 'description': '注册时间'}
                                }
                            },
                            'attributes': {
                                'type': 'object',
                                'description': '用户自定义属性',
                                'additionalProperties': {'type': 'string'}
                            },
                            'organizedActivities': {
                                'type': 'array',
                                'description': '用户组织的活动列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'title': {'type': 'string'},
                                        'description': {'type': 'string'},
                                        'start_time': {'type': 'string'},
                                        'end_time': {'type': 'string'},
                                        'current_participants': {'type': 'integer'},
                                        'max_participants': {'type': 'integer'},
                                        'status': {'type': 'string'}
                                    }
                                }
                            },
                            'participatedActivities': {
                                'type': 'array', 
                                'description': '用户参加的活动列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'title': {'type': 'string'},
                                        'description': {'type': 'string'},
                                        'start_time': {'type': 'string'},
                                        'end_time': {'type': 'string'},
                                        'organizer_name': {'type': 'string'},
                                        'status': {'type': 'string'}
                                    }
                                }
                            },
                            'friends': {
                                'type': 'array',
                                'description': '用户好友列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'nickname': {'type': 'string'},
                                        'avatar_url': {'type': 'string'},
                                        'created_at': {'type': 'string', 'description': '添加好友时间'}
                                    }
                                }
                            },
                            'statistics': {
                                'type': 'object',
                                'properties': {
                                    'organized_count': {'type': 'integer', 'description': '组织活动数量'},
                                    'participated_count': {'type': 'integer', 'description': '参与活动数量'},
                                    'friends_count': {'type': 'integer', 'description': '好友数量'}
                                }
                            }
                        }
                    }
                }
            }
        },
        401: {
            'description': 'token验证失败或用户不存在'
        }
    }
})
def get_user_info():
    """获取用户信息"""
    try:
        from flask import g
        from app.models.activity import Activity, ActivityParticipant
        from app.models.user_relation import UserRelation
        db = get_db()
        
        user = User.query.get(g.user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        # 获取用户组织的活动
        organized_activities = Activity.query.filter_by(
            organizer_id=user.id,
            is_active=True
        ).order_by(Activity.start_time.desc()).limit(10).all()
        
        # 获取用户参加的活动
        participated_activities_query = db.session.query(Activity).join(
            ActivityParticipant, Activity.id == ActivityParticipant.activity_id
        ).filter(
            ActivityParticipant.user_id == user.id,
            ActivityParticipant.status == 'joined',
            Activity.is_active == True
        ).order_by(Activity.start_time.desc()).limit(10).all()
        
        # 获取用户好友列表
        friends_relations = UserRelation.query.filter_by(
            owner_id=user.id,
            relation_type='friend'
        ).order_by(UserRelation.created_at.desc()).limit(10).all()
        
        # 构建组织活动数据
        organized_activities_data = []
        for activity in organized_activities:
            organized_activities_data.append({
                'id': activity.id,
                'title': activity.title,
                'description': activity.description,
                'start_time': activity.start_time.strftime('%Y-%m-%d %H:%M:%S') if activity.start_time else None,
                'end_time': activity.end_time.strftime('%Y-%m-%d %H:%M:%S') if activity.end_time else None,
                'current_participants': activity.current_participants,
                'max_participants': activity.max_participants,
                'status': activity.status,
                'activity_type': activity.activity_type,
                'is_free': activity.is_free,
                'fee': float(activity.fee) if activity.fee else 0
            })
        
        # 构建参加活动数据
        participated_activities_data = []
        for activity in participated_activities_query:
            organizer_name = activity.organizer.nickname if activity.organizer else '未知'
            participated_activities_data.append({
                'id': activity.id,
                'title': activity.title,
                'description': activity.description,
                'start_time': activity.start_time.strftime('%Y-%m-%d %H:%M:%S') if activity.start_time else None,
                'end_time': activity.end_time.strftime('%Y-%m-%d %H:%M:%S') if activity.end_time else None,
                'organizer_id': activity.organizer_id,
                'organizer_name': organizer_name,
                'status': activity.status,
                'activity_type': activity.activity_type,
                'is_free': activity.is_free,
                'fee': float(activity.fee) if activity.fee else 0
            })
        
        # 构建好友数据
        friends_data = []
        for relation in friends_relations:
            if relation.target:
                friends_data.append({
                    'id': relation.target.id,
                    'nickname': relation.target.nickname,
                    'avatar_url': relation.target.avatar_url,
                    'phone': relation.target.phone,
                    'created_at': relation.created_at.strftime('%Y-%m-%d %H:%M:%S') if relation.created_at else None
                })
        
        # 获取用户自定义属性
        user_attributes = UserAttribute.get_user_attributes(int(g.user_id))
        
        # 构建响应数据
        response_data = {
            'userInfo': user.to_dict(),
            'attributes': user_attributes,
            'organizedActivities': organized_activities_data,
            'participatedActivities': participated_activities_data,
            'friends': friends_data,
            'statistics': {
                'organized_count': len(organized_activities_data),
                'participated_count': len(participated_activities_data),
                'friends_count': len(friends_data)
            }
        }
        
        return success_response(response_data, '获取成功')
    
    except Exception as e:
        current_app.logger.error(f"获取用户信息失败: {str(e)}")
        return error_response('获取失败', 500)

@auth_bp.route('/update', methods=['PUT'])
@login_required
@swag_from({
    'tags': ['用户认证'],
    'summary': '更新用户信息',
    'description': '用户更新个人信息，需要在请求头中包含JWT token。用户只能更新自己的基本信息，不能修改手机号和激活状态。',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'Authorization',
            'in': 'header',
            'required': True,
            'type': 'string',
            'description': 'JWT token，格式：Bearer {token}'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'nickname': {'type': 'string', 'description': '用户昵称'},
                    'avatar_url': {'type': 'string', 'description': '头像URL'},
                    'gender': {'type': 'integer', 'enum': [0, 1, 2], 'description': '性别：0=未知，1=男，2=女'},
                    'attributes': {'type': 'object', 'description': '用户自定义属性（键值对）', 'additionalProperties': {'type': 'string'}}
                },
                'example': {
                    'nickname': '新昵称',
                    'avatar_url': 'https://example.com/avatar.jpg',
                    'gender': 1,
                    'attributes': {
                        'favorite_sport': '篮球',
                        'skill_level': '中级',
                        'bio': '热爱运动的程序员'
                    }
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '更新成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '更新成功'},
                    'data': {
                        'type': 'object',
                        'description': '更新后的用户完整信息',
                        'properties': {
                            'userInfo': {
                                'type': 'object',
                                'description': '用户基本信息',
                                'properties': {
                                    'id': {'type': 'integer', 'description': '用户ID'},
                                    'nickname': {'type': 'string', 'description': '用户昵称'},
                                    'phone': {'type': 'string', 'description': '手机号'},
                                    'avatar_url': {'type': 'string', 'description': '头像URL'},
                                    'gender': {'type': 'integer', 'description': '性别：0-未知，1-男，2-女'},
                                    'is_active': {'type': 'boolean', 'description': '是否活跃'},
                                    'created_at': {'type': 'string', 'description': '注册时间'},
                                    'updated_at': {'type': 'string', 'description': '更新时间'}
                                }
                            },
                            'attributes': {
                                'type': 'object',
                                'description': '用户自定义属性',
                                'additionalProperties': {'type': 'string'}
                            },
                            'organizedActivities': {
                                'type': 'array',
                                'description': '用户组织的活动列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'title': {'type': 'string'},
                                        'description': {'type': 'string'},
                                        'start_time': {'type': 'string'},
                                        'end_time': {'type': 'string'},
                                        'current_participants': {'type': 'integer'},
                                        'max_participants': {'type': 'integer'},
                                        'status': {'type': 'string'}
                                    }
                                }
                            },
                            'participatedActivities': {
                                'type': 'array', 
                                'description': '用户参加的活动列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'title': {'type': 'string'},
                                        'description': {'type': 'string'},
                                        'start_time': {'type': 'string'},
                                        'end_time': {'type': 'string'},
                                        'organizer_name': {'type': 'string'},
                                        'status': {'type': 'string'}
                                    }
                                }
                            },
                            'friends': {
                                'type': 'array',
                                'description': '用户好友列表',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'nickname': {'type': 'string'},
                                        'avatar_url': {'type': 'string'},
                                        'created_at': {'type': 'string', 'description': '添加好友时间'}
                                    }
                                }
                            },
                            'statistics': {
                                'type': 'object',
                                'properties': {
                                    'organized_count': {'type': 'integer', 'description': '组织活动数量'},
                                    'participated_count': {'type': 'integer', 'description': '参与活动数量'},
                                    'friends_count': {'type': 'integer', 'description': '好友数量'}
                                }
                            }
                        }
                    }
                }
            }
        },
        400: {
            'description': '请求参数错误',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 400},
                    'message': {'type': 'string', 'example': '无效的请求数据'}
                }
            }
        },
        401: {
            'description': 'token验证失败'
        },
        404: {
            'description': '用户不存在'
        }
    }
})
def update_user_info():
    """更新用户信息"""
    try:
        from flask import g
        from app.models.activity import Activity, ActivityParticipant
        from app.models.user_relation import UserRelation
        db = get_db()
        
        user = User.query.get(int(g.user_id))
        if not user:
            return error_response('用户不存在', 404)
        
        data = request.get_json()
        if not data:
            return error_response('无效的请求数据', 400)
        
        # 记录更新的字段
        updated_fields = []
        
        # 更新允许的字段
        if 'nickname' in data:
            if data['nickname'] is None or data['nickname'] == '' or not str(data['nickname']).strip():
                return error_response('昵称不能为空', 400)
            user.nickname = str(data['nickname']).strip()
            updated_fields.append('昵称')
        
        if 'avatar_url' in data:
            user.avatar_url = data['avatar_url']
            updated_fields.append('头像')
        
        if 'gender' in data:
            if not isinstance(data['gender'], int) or data['gender'] not in [0, 1, 2]:
                return error_response('性别参数无效，必须为0(未知)、1(男)或2(女)', 400)
            user.gender = data['gender']
            updated_fields.append('性别')
        
        # 更新用户属性（完全替换）
        if 'attributes' in data and isinstance(data['attributes'], dict):
            try:
                UserAttribute.replace_user_attributes(int(g.user_id), data['attributes'])
                updated_fields.append('自定义属性')
            except Exception as e:
                current_app.logger.error(f"更新用户属性失败: {str(e)}")
                return error_response('用户属性更新失败', 400)
        
        # 检查是否有有效的更新
        if not updated_fields:
            return error_response('没有有效的更新字段', 400)
        
        db.session.commit()
        
        # 构建成功消息
        update_msg = f'更新成功，已更新：{", ".join(updated_fields)}'
        
        # 获取更新后的完整用户信息（包括属性）
        user_data = user.to_dict()
        user_attributes = UserAttribute.get_user_attributes(int(g.user_id))
        
        # 获取用户组织的活动
        organized_activities = Activity.query.filter_by(
            organizer_id=user.id,
            is_active=True
        ).order_by(Activity.start_time.desc()).limit(10).all()
        
        # 获取用户参加的活动
        participated_activities_query = db.session.query(Activity).join(
            ActivityParticipant, Activity.id == ActivityParticipant.activity_id
        ).filter(
            ActivityParticipant.user_id == user.id,
            ActivityParticipant.status == 'joined',
            Activity.is_active == True
        ).order_by(Activity.start_time.desc()).limit(10).all()
        
        # 获取用户好友列表
        friends_relations = UserRelation.query.filter_by(
            owner_id=user.id,
            relation_type='friend'
        ).order_by(UserRelation.created_at.desc()).limit(10).all()
        
        # 构建组织活动数据
        organized_activities_data = []
        for activity in organized_activities:
            organized_activities_data.append({
                'id': activity.id,
                'title': activity.title,
                'description': activity.description,
                'start_time': activity.start_time.strftime('%Y-%m-%d %H:%M:%S') if activity.start_time else None,
                'end_time': activity.end_time.strftime('%Y-%m-%d %H:%M:%S') if activity.end_time else None,
                'current_participants': activity.current_participants,
                'max_participants': activity.max_participants,
                'status': activity.status,
                'activity_type': activity.activity_type,
                'is_free': activity.is_free,
                'fee': float(activity.fee) if activity.fee else 0
            })
        
        # 构建参加活动数据
        participated_activities_data = []
        for activity in participated_activities_query:
            organizer_name = activity.organizer.nickname if activity.organizer else '未知'
            participated_activities_data.append({
                'id': activity.id,
                'title': activity.title,
                'description': activity.description,
                'start_time': activity.start_time.strftime('%Y-%m-%d %H:%M:%S') if activity.start_time else None,
                'end_time': activity.end_time.strftime('%Y-%m-%d %H:%M:%S') if activity.end_time else None,
                'organizer_id': activity.organizer_id,
                'organizer_name': organizer_name,
                'status': activity.status,
                'activity_type': activity.activity_type,
                'is_free': activity.is_free,
                'fee': float(activity.fee) if activity.fee else 0
            })
        
        # 构建好友数据
        friends_data = []
        for relation in friends_relations:
            if relation.target:
                friends_data.append({
                    'id': relation.target.id,
                    'nickname': relation.target.nickname,
                    'avatar_url': relation.target.avatar_url,
                    'phone': relation.target.phone,
                    'created_at': relation.created_at.strftime('%Y-%m-%d %H:%M:%S') if relation.created_at else None
                })
        
        # 构建返回数据
        response_data = {
            'userInfo': user_data,
            'attributes': user_attributes,
            'organizedActivities': organized_activities_data,
            'participatedActivities': participated_activities_data,
            'friends': friends_data,
            'statistics': {
                'organized_count': len(organized_activities_data),
                'participated_count': len(participated_activities_data),
                'friends_count': len(friends_data)
            }
        }
        
        return success_response(response_data, update_msg)
    
    except Exception as e:
        current_app.logger.error(f"更新用户信息失败: {str(e)}")
        db.session.rollback()
        return error_response('更新失败', 500)

@auth_bp.route('/mock_register', methods=['POST'])
@swag_from({
    'tags': ['用户认证'],
    'summary': '模拟注册（测试用）',
    'description': '模拟用户注册接口，用于测试目的，创建一个新的测试用户或返回已存在的用户',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'user_id': {'type': 'integer', 'description': '希望创建的用户ID（可选）'},
                    'nickname': {'type': 'string', 'description': '用户昵称'},
                    'phone': {'type': 'string', 'description': '手机号'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '注册或获取用户成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer'},
                    'message': {'type': 'string'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer'},
                            'nickname': {'type': 'string'}
                        }
                    }
                }
            }
        }
    }
})
def mock_register():
    """模拟注册一个测试用户"""
    db = get_db()
    data = request.get_json()
    user_id = data.get('user_id')
    nickname = data.get('nickname')
    phone = data.get('phone')

    if user_id:
        user = User.query.get(user_id)
        if user:
            return success_response(user.to_dict(), "用户已存在")

    if phone:
        user = User.query.filter_by(phone=phone).first()
        if user:
            return success_response(user.to_dict(), "该手机号已被注册")
    
    new_user = User(
        id=user_id,
        nickname=nickname,
        phone=phone,
        openid=f"mock_openid_{nickname}" # 使用唯一的openid
    )
    db.session.add(new_user)
    db.session.commit()
    
    return success_response(new_user.to_dict(), "模拟注册成功")

@auth_bp.route('/mock_login', methods=['POST'])
@swag_from({
    'tags': ['用户认证'],
    'summary': '模拟登录（测试用）',
    'description': '模拟用户登录接口，用于测试目的，无需真实的微信认证',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['user_id'],
                'properties': {
                    'user_id': {'type': 'integer', 'description': '用户ID', 'example': 1},
                    'phone': {'type': 'string', 'description': '手机号（可选）', 'example': '13800138000'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '登录成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '登录成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'userId': {'type': 'integer', 'description': '用户ID'},
                            'token': {'type': 'string', 'description': 'JWT访问令牌'},
                            'userInfo': {'type': 'object', 'description': '用户信息'}
                        }
                    }
                }
            }
        }
    }
})
def mock_login():
    """模拟用户登录"""
    db = get_db()
    data = request.get_json()
    if not data or 'user_id' not in data:
        return error_response('缺少user_id', 400)
    
    user_id = data.get('user_id')
    user = User.query.get(user_id)
    
    if not user:
        # 如果用户不存在，可以创建一个临时的
        user = User(id=user_id, nickname=f'Mock User {user_id}', phone=data.get('phone', f'138000000{user_id:02d}'))
        db.session.add(user)
        db.session.commit()
    
    # ***** 手动生成一个永不过期的Token *****
    # 密钥已在应用启动时全局配置，此处无需重复传入
    access_token = create_access_token(identity=str(user.id), expires_delta=False)

    return success_response({
        'userId': user.id,
        'token': access_token,
        'userInfo': user.to_dict()
    }, '登录成功')